package com.example.server.util;


import cn.hutool.core.lang.Dict;
import com.azure.ai.openai.OpenAIClient;
import com.azure.ai.openai.OpenAIClientBuilder;
import com.azure.core.credential.AzureKeyCredential;
import com.example.server.manage.gptdialogue.properties.GptProperties;
import com.example.server.manage.gptdialogue.server.ChatGptSseService;
import com.example.server.util.threadpool.XjThreadUtil;
import com.example.server.util.validated.ValidUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.ai.azure.openai.AzureOpenAiChatClient;
import org.springframework.ai.azure.openai.AzureOpenAiChatOptions;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

import java.net.Proxy;
import java.util.ArrayList;
import java.util.List;

@Service
@Slf4j
public class FluxTest {


    public static void main(String[] args) {

        // Flux<T> t 的数据类型, 就是 sink.next 添加的数据类型, 建议使用对象, 不要使用基础数据类型
        Flux<Dict> flux = Flux.create(sink -> {
            // 模拟数据进行推送, 这个一定是在异步消息中, 不在异步中发送消息时会阻塞主线程
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    Dict dict = Dict.create().set("value", i + "");
                    sink.next(dict);
                    // 模拟延时
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                // 完成流的发送
                sink.complete();

                //  try 异常可使用
                //  sink.error(e); // 如果发生异常，推送错误到流
            }).start();
        });


        // 订阅消息
        flux.subscribe(
                res -> {
                    // 处理每个 Dict 数据
                    System.out.println("Received res: " + res);
                },
                error -> {
                    // 错误处理
                    System.err.println("Error: " + error);
                },
                () -> {
                    // 完成流处理时的回调
                    System.out.println("Stream completed.");
                }
        );
    }
}
